#include<iostream>
using namespace std;

#include<assert.h>


#include <time.h>
struct A { int a[10000]; };

void TestFunc1(A a) {}
void TestFunc2(A& a) {}

void TestRefAndValue()
{
	A a;
	// 以值作为函数参数
	size_t begin1 = clock();
	for (size_t i = 0; i < 10000; ++i)
		TestFunc1(a);
	size_t end1 = clock();

	// 以引用作为函数参数
	size_t begin2 = clock();
	for (size_t i = 0; i < 10000; ++i)
		TestFunc2(a);
	size_t end2 = clock();

	// 分别计算两个函数运行结束后的时间
	cout << "TestFunc1(A)-time:" << end1 - begin1 << endl;
	cout << "TestFunc2(A&)-time:" << end2 - begin2 << endl;
}

// int main()
// {
// 	TestRefAndValue();

// 	return 0;
// }


// int main()
// {
// 	// 权限可以平移/缩小 不能放大
// 	double d = 12.34;

// 	// 类型转换
// 	int i = d;

//     //类型转换会产生临时变量,临时变量具有常性(所以不加const就是权限的放大)
//     // int& r1 = d;
// 	const int& r1 = d;

// 	int x = 0, y = 1;
//     //表达式也是会产生临时变量
// 	const int& r2 = x + y;

// 	return 0;
// }


// int main()
// {
// 	int a = 0;
// 	int& b = a;  // 语法上不开空间
// 	int* p = &a; // 语法上要开空间

// 	int* ptr = NULL;
// 	int& r = *ptr;
// 	//cout << r << endl;

// 	cout << sizeof(b) << endl;
// 	cout << sizeof(int&) << endl;
// 	b++;
// 	p++;

// 	return 0;
// }

//////////////////////////////////////////////////////////
// void swap(int& a, int& b)
// {
// 	//...
// }

// // 频繁调用的小函数
// // C->宏函数

// // #define ADD(int a, int b) return a + b;
// #define ADD(a, b) a + b;
// #define ADD(a, b) (a + b)
// #define ADD(a, b) ((a) + (b))
// // 为什么不能加分号?
// // 为什么要加外面的括号?
// // 为什么要加里面的括号?

// int main()
// {
// 	int ret = ADD(1, 2);
// 	cout << ADD(1, 2) << endl;
// 	int x = 1, y = 2;
// 	ADD(x & y, x | y);  // -> (x&y+x|y)

// 	return 0;
// }

// Debug版本下面默认是不展开的->方便调试
// inline int Add(int a, int b)
// {
// 	int ret = a + b;
// 	cout << ret << endl;
// 	cout << ret << endl;
// 	cout << ret << endl;
// 	cout << ret << endl;
// 	cout << ret << endl;
// 	cout << ret << endl;
// 	cout << ret << endl;
// 	cout << ret << endl;
// 	cout << ret << endl;
// 	cout << ret << endl;
// 	cout << ret << endl;
// 	cout << ret << endl;
// 	return a + b;
// }

// int main()
// {
// 	int c1 = Add(1, 2);
// 	cout << c1 << endl;

// 	int c2 = Add(1, 2);
// 	cout << c2 << endl;

// 	return 0;
// }



//#include"F.h"
//
//int main()
//{
//	f(10); // call ?f@@YAXH@Z(?)
//
//	return 0;
//}
#include<map>
#include<string>

//int main()
//{
//	int j = 0;
//
//	// 右边初始化自动推导类型
//	auto i = 0;
//	std::map<std::string, std::string> dict;
//
//	// 等价的，auto可以替代写起来比较长的类型的定义，简化代码
//	//std::map<std::string, std::string>::iterator it = dict.begin();
//	auto it = dict.begin();
//
//	return 0;
//}

//typedef char* pstring;
//
//int main()
//{
//	const pstring p1; // 编译成功还是失败？
//	const pstring* p2; // 编译成功还是失败？
//	return 0;
//}

int TestAuto()
{
	return 10;
}

//int main()
//{
//	//int a = 10;
//	//auto b = a;
//	//auto c = 'a';
//	//auto d = TestAuto();
//
//	//cout << typeid(b).name() << endl;
//	//cout << typeid(c).name() << endl;
//	//cout << typeid(d).name() << endl;
//
	// int x = 10;

	// auto a1 = x;
	// auto a2 = &x;

	// // 指定必须是指针
	// auto* b = &x;

	// // 引用
	// auto& c = x;
//}

// 不支持
// void TestFor(int array[])
// {
// 	for (auto& e : array)
// 		cout << e << endl;
// }

// C/C++ 极度追求效率

// int main()
// {
// 	int array[] = { 1, 2, 3, 4, 5 };

// 	for (int i = 0; i < sizeof(array) / sizeof(array[0]); ++i)
// 	{
// 		array[i] *= 2;
// 	}
	
// 	for (int i = 0; i < sizeof(array) / sizeof(array[0]); ++i)
// 	{
// 		cout << array[i] << " ";
// 	}
// 	cout << endl;

// 	// C++11 范围for
// 	// 自动取数组array中，赋值给e
// 	// 自动++，自动判断结束
// 	for (auto& e : array)
// 	{
// 		e /= 2;
// 	}

// 	for (int x : array)
// 	{
// 		cout << x << " ";
// 	}
// 	cout << endl;

// 	return 0;
// }

//void f(int i)
//{
//	cout << "f(int)" << endl;
//}
//
//void f(int* p)
//{
//	cout << "f(int*)" << endl;
//}
//
//int main()
//{
//	f(0);
//	f(NULL);
//	f((int*)NULL);
//	f(nullptr);
//
//	return 0;
//}




//int main()
//{
//	return 0;
//}

// C++兼容C中struct的用法
// 类和对象
// 1个类 实例化 N个对象

// C++升级struct升级成了类
// 1、类里面可以定义函数
// 2、struct名称就可以代表类型

// C++兼容C中struct的用法
// typedef struct ListNodeC
// {
// 	struct ListNodeC* next;
// 	int val;
// }LTNode;

// struct ListNodeCPP
// {
// 	ListNodeCPP* next;
// 	int val;
// };

// struct Stack
// {
// 	// 成员函数
// 	void Init(int n = 4)
// 	{
// 		array = (int*)malloc(sizeof(int) * n);
// 		if (nullptr == array)
// 		{
// 			perror("malloc申请空间失败");
// 			return;
// 		}

// 		capacity = n;
// 		top = 0;
// 	}

// 	// 成员变量
// 	int* array;
// 	size_t capacity;
// 	size_t top;
// };

// //void StackInit(struct Stack* ps, int n)
// //{}

// int main()
// {
// 	struct Stack st1;
// 	st1.Init(100);

// 	Stack st2;
// 	st2.Init();

// 	LTNode node1;
// 	ListNodeCPP node2;

// 	return 0;
// }

//////////////////////////////////////////////////////////////////////////
// class Stack
// {
// public:
// 	// 成员函数
// 	void Init(int n = 4)
// 	{
// 		array = (int*)malloc(sizeof(int) * n);
// 		if (nullptr == array)
// 		{
// 			perror("malloc申请空间失败");
// 			return;
// 		}

// 		capacity = n;
// 		top = 0;
// 	}

// 	void Push(int x)
// 	{
// 		// ...扩容
// 		array[top++] = x;
// 	}

// 	int Top()
// 	{
// 		assert(top > 0);

// 		return array[top - 1];
// 	}

// private:
// 	// 成员变量
// 	int* array;
// 	size_t capacity;
// 	size_t top;
// };

// // 封装
// int main()
// {
// 	//class Stack st1;
// 	Stack st2;
// 	st2.Init();
// 	st2.Push(1);
// 	st2.Push(2);
// 	st2.Push(3);
// 	st2.Push(4);

// 	//cout << st2.array[st2.top] << endl;
// 	cout << st2.Top() << endl;


// 	return 0;
// }







class Date
{
public:
	void Init(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}

private:
	int _year; // year_  m_year
	int _month;
	int _day;
};

int main()
{
	Date d;
	d.Init(2024, 3, 31);

	return 0;
}